home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / public / Xprof / xmeasure / tstwins.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  14KB  |  562 lines
  1. /*==================================================================
  2.  *      File :          tstwins.c
  3.  *      Package:        Xmeasure
  4.  * 
  5.  *      Author :        Aloke Gupta.
  6.  *
  7.  *  (C) Copyright 1992, Aloke Gupta.
  8.  *  All rights granted to University of Illinois Board of Regents.
  9.  *==================================================================*/
  10.  
  11. #include "perf.h"
  12.  
  13.  
  14. /* Number of subwindows for some tests */
  15. #define NUMSUBWINDOWS 8
  16.  
  17. #define SUBWINHEIGHT 32 
  18. #define SUBWINWIDTH  32
  19.  
  20. #define SEPARATION    3
  21.  
  22. /* Shared variables */
  23. static int i;
  24. static Window window;
  25. static Window *winarray;
  26. static XSetWindowAttributes xswa;
  27. static XWindowAttributes    xwa;
  28.  
  29. /* ====================================================================== */
  30.  
  31. int   CreateWindow(xd, xp)
  32. XD *xd;
  33. XParams *xp;
  34. {
  35.     for (i = 0; i < xp->itns; i++) {
  36.         window = XCreateSimpleWindow(xd->display, xd->window, 0, 0,
  37.             SUBWINWIDTH, SUBWINHEIGHT, 1, xd->foreground, xd->background);
  38. /*    XMapWindow(xd->display, window); */
  39.     }
  40. }
  41.  
  42. int i_CreateWindow(xd, xp)
  43. XD *xd;
  44. XParams *xp;
  45. {    /* nothing to initialize */ }
  46.  
  47. int c_CreateWindow(xd, xp)
  48. XD *xd;
  49. XParams *xp;
  50. {
  51.     XDestroySubwindows(xd->display, xd->window);
  52. }
  53.  
  54. /* ====================================================================== */
  55.  
  56. int   ChangeWindowAttributes(xd, xp)
  57. XD *xd;
  58. XParams *xp;
  59. {
  60.     unsigned long valuemask=0;
  61.  
  62.     valuemask  = CWBitGravity | CWEventMask;
  63.     xswa.bit_gravity = NorthWestGravity;
  64.     xswa.event_mask = ButtonPressMask;
  65.     for (i = 0; i < xp->itns; i++) 
  66.     XChangeWindowAttributes(xd->display, window,valuemask,&xswa);
  67. }
  68.  
  69. int i_ChangeWindowAttributes(xd, xp)
  70. XD *xd;
  71. XParams *xp;
  72. {    
  73.     window = XCreateSimpleWindow(xd->display, xd->window, 0, 0,
  74.     SUBWINWIDTH, SUBWINHEIGHT, 1, xd->foreground, xd->background);
  75.     XMapWindow(xd->display, window); 
  76. }
  77.  
  78. int c_ChangeWindowAttributes(xd, xp)
  79. XD *xd;
  80. XParams *xp;
  81. {
  82.     XDestroySubwindows(xd->display, xd->window);
  83. }
  84.  
  85. /* ====================================================================== */
  86.  
  87. int   GetWindowAttributes(xd, xp)
  88. XD *xd;
  89. XParams *xp;
  90. {
  91.     for (i = 0; i < xp->itns; i++) 
  92.     XGetWindowAttributes(xd->display, xd->window, &xwa);
  93. }
  94.  
  95. int i_GetWindowAttributes(xd, xp)
  96. XD *xd;
  97. XParams *xp;
  98. {
  99. }
  100.  
  101. int c_GetWindowAttributes(xd, xp)
  102. XD *xd;
  103. XParams *xp;
  104. {
  105. }
  106.  
  107. /* ====================================================================== */
  108.  
  109. int   DestroyWindow(xd, xp)  
  110. XD *xd;
  111. XParams *xp;
  112. {
  113.     for (i = 0; i < xp->itns; i++)
  114.     XDestroyWindow(xd->display, winarray[i]);
  115. }
  116.  
  117. int i_DestroyWindow(xd, xp)  
  118. XD *xd;
  119. XParams *xp;
  120. {
  121.     winarray = (Window *) malloc(xp->itns * sizeof(Window) );
  122.     for (i = 0; i < xp->itns; i++) {
  123.     winarray[i] = XCreateSimpleWindow(xd->display, xd->window, 0, 0,
  124.         SUBWINWIDTH, SUBWINHEIGHT, 1, xd->foreground, xd->background);
  125.     }
  126. }
  127.  
  128. int c_DestroyWindow(xd, xp)  
  129. XD *xd;
  130. XParams *xp;
  131. {
  132.     XDestroySubwindows(xd->display, xd->window);
  133.     free(winarray);
  134. }
  135.  
  136. /* ====================================================================== */
  137.  
  138. /* This function is tricky since it will be have variable execution time
  139.  * depending on the number of subwindows in practice.
  140.  */
  141. int   DestroySubwindows(xd, xp)
  142. XD *xd;
  143. XParams *xp;
  144. {
  145.     for (i = 0; i < xp->itns; i++)
  146.     XDestroySubwindows(xd->display, winarray[i]);
  147. }
  148. int i_DestroySubwindows(xd, xp)
  149. XD *xd;
  150. XParams *xp;
  151. {
  152.     int num;    /* Count of number of subwindows to create */
  153.  
  154.     winarray = (Window *) malloc(xp->itns * sizeof(Window) );
  155.     for (i = 0 ; i < xp->itns; i++) {
  156.     winarray[i] = XCreateSimpleWindow(xd->display, xd->window, 0, 0,
  157.         DISPWIDTH, DISPHEIGHT, 1, xd->foreground, xd->background);
  158.     for (num = 0; num < NUMSUBWINDOWS; num++) 
  159.         window = XCreateSimpleWindow(xd->display, winarray[i], 0, 0,
  160.         SUBWINWIDTH, SUBWINHEIGHT, 1, xd->foreground, xd->background);
  161.     }
  162. }
  163.  
  164. int c_DestroySubwindows(xd, xp)
  165. XD *xd;
  166. XParams *xp;
  167. {
  168.     XDestroySubwindows(xd->display, xd->window);
  169.     free(winarray);
  170. }
  171.  
  172. /* ====================================================================== */
  173.  
  174. int   ChangeSaveSet(xd, xp)  
  175. XD *xd;
  176. XParams *xp;
  177. {
  178. }
  179. int i_ChangeSaveSet(xd, xp)  
  180. XD *xd;
  181. XParams *xp;
  182. {
  183. }
  184. int c_ChangeSaveSet(xd, xp)  
  185. XD *xd;
  186. XParams *xp;
  187. {
  188. }
  189.  
  190. /* ====================================================================== */
  191.  
  192. int   ReparentWindow(xd, xp) 
  193. XD *xd;
  194. XParams *xp;
  195. {
  196.     for (i = 0; i < xp->itns; i++)
  197.     XReparentWindow(xd->display, winarray[i], xd->window, 0, 0);
  198. }
  199.  
  200. int i_ReparentWindow(xd, xp) 
  201. XD *xd;
  202. XParams *xp;
  203. {
  204.     window = XCreateSimpleWindow(xd->display, xd->window, 0, 0,
  205.     SUBWINWIDTH, SUBWINHEIGHT, 1, xd->foreground, xd->background);
  206.     winarray = (Window *) malloc(xp->itns * sizeof(Window) );
  207.     for (i = 0; i < xp->itns; i++)
  208.     winarray[i] = XCreateSimpleWindow(xd->display, window, 0, 0,
  209.         SUBWINWIDTH, SUBWINHEIGHT, 1, xd->foreground, xd->background);
  210. }
  211.  
  212. int c_ReparentWindow(xd, xp) 
  213. XD *xd;
  214. XParams *xp;
  215. {
  216.     XDestroySubwindows(xd->display, xd->window);
  217.     free(winarray);
  218. }
  219.  
  220. /* ====================================================================== */
  221.  
  222. int   MapWindow(xd, xp)      
  223. XD *xd;
  224. XParams *xp;
  225. {
  226.     for (i = 0; i < xp->itns; i++)
  227.     XMapWindow(xd->display, winarray[i]);
  228. }
  229.  
  230. int i_MapWindow(xd, xp)      
  231. XD *xd;
  232. XParams *xp;
  233. {
  234.     int xoffset=SEPARATION, yoffset=SEPARATION;
  235.  
  236.     winarray = (Window *) malloc(xp->itns * sizeof(Window) );
  237.     for (i = 0; i < xp->itns; i++) {
  238.     winarray[i] = XCreateSimpleWindow(xd->display, xd->window,
  239.             xoffset, yoffset, SUBWINWIDTH, SUBWINHEIGHT, 1,
  240.             xd->foreground, xd->background);
  241.     yoffset += SUBWINHEIGHT + SEPARATION;
  242.     if (yoffset > (DISPHEIGHT  - SUBWINHEIGHT)) {
  243.         yoffset  = SEPARATION;
  244.         xoffset += SUBWINWIDTH + SEPARATION;
  245.         if (xoffset > (DISPWIDTH - SUBWINWIDTH))
  246.         xoffset = SEPARATION;
  247.     }
  248.     }
  249. }
  250.  
  251. int c_MapWindow(xd, xp)      
  252. XD *xd;
  253. XParams *xp;
  254. {
  255.     XDestroySubwindows(xd->display, xd->window);
  256.     free(winarray);
  257. }
  258.  
  259. /* ====================================================================== */
  260. /* This function is tricky since it will be have variable execution time
  261.  * depending on the number of subwindows in practice.
  262.  */
  263.  
  264. int   MapSubwindows(xd, xp)  
  265. XD *xd;
  266. XParams *xp;
  267. {
  268.     for (i = 0; i < xp->itns; i++) 
  269.     XMapSubwindows(xd->display, winarray[i]);
  270. }
  271.  
  272. int i_MapSubwindows(xd, xp)  
  273. XD *xd;
  274. XParams *xp;
  275. {
  276.     int num;            /* Count of number of subwindows to create */
  277.     int winx = SEPARATION, winy= SEPARATION;  /* Coordinates of high level
  278.                              window */
  279.     int xoffset = SEPARATION, yoffset = SEPARATION;
  280.     int xsize, ysize;     /* Size of the little subwindows */
  281.  
  282.     xsize = SUBWINWIDTH  / NUMSUBWINDOWS;
  283.     ysize = SUBWINHEIGHT / NUMSUBWINDOWS;
  284.     winarray = (Window *) malloc(xp->itns * sizeof(Window) );
  285.     for (i = 0 ; i < xp->itns; i++) {
  286.         winarray[i] = XCreateSimpleWindow(xd->display, xd->window, winx, winy,
  287.             SUBWINWIDTH, SUBWINHEIGHT, 1, xd->foreground, xd->background);
  288.     winy += SUBWINHEIGHT + SEPARATION;
  289.     if (winy > (DISPHEIGHT - SUBWINHEIGHT)) {
  290.         winy = SEPARATION;
  291.         winx += SUBWINWIDTH + SEPARATION;
  292.         if (winx > (DISPWIDTH - SUBWINWIDTH))
  293.         winx = SEPARATION;
  294.     }
  295.     XMapWindow(xd->display, winarray[i]);
  296.  
  297.     xoffset=SEPARATION; yoffset=SEPARATION;
  298.         for (num = 0; num < NUMSUBWINDOWS; num++) {
  299.             window = XCreateSimpleWindow(xd->display, winarray[i],
  300.         xoffset,yoffset,xsize,ysize,1,xd->foreground,xd->background);
  301.         yoffset += ysize + SEPARATION;
  302.         if (yoffset > (SUBWINHEIGHT  - ysize)) {
  303.         yoffset  = SEPARATION;
  304.         xoffset += xsize + SEPARATION;
  305.         if (xoffset > (SUBWINWIDTH - xsize))
  306.             xoffset = SEPARATION;
  307.         }
  308.     }
  309.     }
  310. }
  311.  
  312. int c_MapSubwindows(xd, xp)  
  313. XD *xd;
  314. XParams *xp;
  315. {
  316.     XDestroySubwindows(xd->display, xd->window);
  317.     free(winarray);
  318. }
  319.  
  320. /* ====================================================================== */
  321.  
  322. int   UnmapWindow(xd, xp)    
  323. XD *xd;
  324. XParams *xp;
  325. {
  326.     for (i = xp->itns; i > 0 ; i--) /* Unmap in reverse order of creation */
  327.     XUnmapWindow(xd->display, winarray[i-1]);
  328. }
  329.  
  330. int i_UnmapWindow(xd, xp)    
  331. XD *xd;
  332. XParams *xp;
  333. {
  334.     int xoffset=SEPARATION, yoffset=SEPARATION;
  335.  
  336.     winarray = (Window *) malloc(xp->itns * sizeof(Window) );
  337.     for (i = 0; i < xp->itns; i++) {
  338.         winarray[i] = XCreateSimpleWindow(xd->display, xd->window,
  339.                         xoffset, yoffset, SUBWINWIDTH, SUBWINHEIGHT,
  340.             1, xd->foreground, xd->background);
  341.     yoffset += SUBWINHEIGHT + SEPARATION;
  342.         if (yoffset > (DISPHEIGHT  - SUBWINHEIGHT)) {
  343.             yoffset  = SEPARATION;
  344.             xoffset += SUBWINWIDTH + SEPARATION;
  345.             if (xoffset > (DISPWIDTH - SUBWINWIDTH))
  346.                 xoffset = SEPARATION;
  347.     }
  348.     XMapWindow(xd->display, winarray[i]);
  349.     }
  350. }
  351.  
  352. int c_UnmapWindow(xd, xp)    
  353. XD *xd;
  354. XParams *xp;
  355. {
  356.     XDestroySubwindows(xd->display, xd->window);
  357.     free(winarray);
  358. }
  359.  
  360. /* ====================================================================== */
  361.  
  362. int   UnmapSubwindows(xd, xp)
  363. XD *xd;
  364. XParams *xp;
  365. {
  366.     for (i = xp->itns; i > 0 ; i--){ /* Unmap in reverse order of creation */
  367.     XUnmapSubwindows(xd->display, winarray[i-1]);
  368.     XUnmapWindow(xd->display, winarray[i-1]);
  369.     }
  370. }
  371. int i_UnmapSubwindows(xd, xp)
  372. XD *xd;
  373. XParams *xp;
  374. {
  375.     int num;    /* Count of number of subwindows created */
  376.     int winx = SEPARATION, winy = SEPARATION; /* Coordinates of high level
  377.                          window */
  378.     int xoffset = SEPARATION, yoffset = SEPARATION;
  379.     int xsize, ysize;   /* Size of the little subwindows */
  380.  
  381.     xsize = SUBWINWIDTH  / NUMSUBWINDOWS;
  382.     ysize = SUBWINHEIGHT / NUMSUBWINDOWS;
  383.     winarray = (Window *) malloc(xp->itns * sizeof(Window) );
  384.     for (i = 0 ; i < xp->itns; i++) {
  385.         winarray[i] = XCreateSimpleWindow(xd->display, xd->window, winx, winy,
  386.         SUBWINWIDTH, SUBWINHEIGHT, 1, xd->foreground, xd->background);
  387.     winy += SUBWINHEIGHT + SEPARATION;
  388.         if (winy > (DISPHEIGHT - SUBWINHEIGHT)) {
  389.             winy = SEPARATION;
  390.             winx += SUBWINWIDTH + SEPARATION;
  391.             if (winx > (DISPWIDTH - SUBWINWIDTH))
  392.                 winx = SEPARATION;
  393.         }
  394.     XMapWindow(xd->display, winarray[i]);
  395.  
  396.     xoffset = yoffset = SEPARATION;
  397.         for (num = 0; num < NUMSUBWINDOWS; num++) {
  398.             window = XCreateSimpleWindow(xd->display, winarray[i],
  399.                 xoffset, yoffset, xsize, ysize,1,xd->foreground,xd->background);
  400.             yoffset += ysize + SEPARATION;
  401.             if (yoffset > (SUBWINHEIGHT  - ysize)) {
  402.                 yoffset  = SEPARATION;
  403.                 xoffset += xsize + SEPARATION;
  404.                 if (xoffset > (SUBWINWIDTH - xsize))
  405.                     xoffset = SEPARATION;
  406.         }
  407.         XMapWindow(xd->display, window);
  408.         }
  409.     XMapSubwindows(xd->display, winarray[i]);
  410.     }
  411. }
  412.  
  413. int c_UnmapSubwindows(xd, xp)
  414. XD *xd;
  415. XParams *xp;
  416. {
  417.     XDestroySubwindows(xd->display, xd->window);
  418.     free(winarray);
  419. }
  420.  
  421. /* ====================================================================== */
  422. static unsigned int changemask;
  423. static XWindowChanges changes;
  424.  
  425. int   ConfigureWindow(xd, xp)
  426. XD *xd;
  427. XParams *xp;
  428. {
  429.     for (i = 0; i < xp->itns; i++) {
  430.     if ((i %2) == 0) { 
  431.         changes.x      = changes.y = 1;
  432.         changes.width  = SUBWINWIDTH / 2;
  433.         changes.height = SUBWINHEIGHT / 2;
  434.         changes.border_width = 2;
  435.         changes.stack_mode   = Above;
  436.     }
  437.     else 
  438.     {
  439.         changes.x      = changes.y = 0;
  440.         changes.width  = SUBWINWIDTH ;
  441.         changes.height = SUBWINHEIGHT;
  442.         changes.border_width = 4;
  443.         changes.stack_mode   = Below;
  444.     }
  445.     XConfigureWindow(xd->display, window, changemask, &changes);
  446.     }
  447. }
  448.  
  449. int i_ConfigureWindow(xd, xp)
  450. XD *xd;
  451. XParams *xp;
  452. {
  453.     window = XCreateSimpleWindow(xd->display, xd->window, 0, 0,
  454.             SUBWINWIDTH, SUBWINHEIGHT, 1, xd->foreground, xd->background);
  455.     XMapWindow(xd->display, window);
  456.     changemask = CWX | CWY | CWStackMode | CWWidth | CWHeight | CWBorderWidth;
  457. }
  458. int c_ConfigureWindow(xd, xp)
  459. XD *xd;
  460. XParams *xp;
  461. {
  462.     XDestroySubwindows(xd->display, xd->window);
  463. }
  464.  
  465. /* ====================================================================== */
  466.  
  467. int   CirculateWindow(xd, xp)
  468. XD *xd;
  469. XParams *xp;
  470. {
  471.     for (i = 0; i < xp->itns; i++ )
  472.     XCirculateSubwindows(xd->display, xd->window, RaiseLowest);
  473. }
  474.  
  475. int i_CirculateWindow(xd, xp)
  476. XD *xd;
  477. XParams *xp;
  478. {
  479.     int num;    /* Count of number of subwindows to create */
  480.     int xoffset=0, yoffset=0;
  481.  
  482.     for (num = 0; num < NUMSUBWINDOWS; num++) {
  483.     window = XCreateSimpleWindow(xd->display, xd->window, xoffset, yoffset,
  484.          SUBWINWIDTH, SUBWINHEIGHT, 1, xd->foreground, xd->background);
  485.     xoffset += 20;
  486.     yoffset += 20;
  487.     xoffset = xoffset % (DISPWIDTH  - SUBWINWIDTH);
  488.     yoffset = yoffset % (DISPHEIGHT - SUBWINHEIGHT);
  489.     }
  490.     XMapSubwindows(xd->display, xd->window);
  491. }
  492.  
  493. int c_CirculateWindow(xd, xp)
  494. XD *xd;
  495. XParams *xp;
  496. {
  497.     XDestroySubwindows(xd->display, xd->window);
  498. }
  499.  
  500. /* ====================================================================== */
  501.  
  502. int   GetGeometry(xd, xp)    
  503. XD *xd;
  504. XParams *xp;
  505. {
  506.     int x, y;
  507.     unsigned int width, height, border_width, depth;
  508.     for (i = 0; i < xp->itns; i++ )
  509.     XGetGeometry(xd->display, xd->window, &window, &x, &y, &width, &height,
  510.           &border_width, &depth);
  511. }
  512.  
  513. int i_GetGeometry(xd, xp)    
  514. XD *xd;
  515. XParams *xp;
  516. {    /* Nothing to initialize */ }
  517.  
  518. int c_GetGeometry(xd, xp)    
  519. XD *xd;
  520. XParams *xp;
  521. {    /* Nothing to cleanup */ }
  522.  
  523. /* ====================================================================== */
  524.  
  525. int   QueryTree(xd, xp)      
  526. XD *xd;
  527. XParams *xp;
  528. {
  529.     Window root, parent, *children; 
  530.     unsigned int nchildren;
  531.  
  532.     for (i = 0; i < xp->itns; i++)
  533.     XQueryTree(xd->display, xd->window,&root,&parent,&children,&nchildren);
  534. }
  535.  
  536. int i_QueryTree(xd, xp)      
  537. XD *xd;
  538. XParams *xp;
  539. {
  540.     int num;    /* Count of number of subwindows to create */
  541.     int xoffset=0, yoffset=0;
  542.  
  543.     for (num = 0; num < NUMSUBWINDOWS; num++) {
  544.     window = XCreateSimpleWindow(xd->display, xd->window, xoffset, yoffset,
  545.          SUBWINWIDTH, SUBWINHEIGHT, 1, xd->foreground, xd->background);
  546.     xoffset += 20;
  547.     yoffset += 20;
  548.     xoffset = xoffset % (DISPWIDTH  - SUBWINWIDTH);
  549.     yoffset = yoffset % (DISPHEIGHT - SUBWINHEIGHT);
  550.     }
  551.     XMapSubwindows(xd->display, xd->window);
  552. }
  553.  
  554. int c_QueryTree(xd, xp)      
  555. XD *xd;
  556. XParams *xp;
  557. {
  558.     XDestroySubwindows(xd->display, xd->window);
  559. }
  560.  
  561. /* ====================================================================== */
  562.